import asyncio
import logging
from asyncio import ensure_future
from functools import wraps
from traceback import format_exception
from typing import Any, Callable, Coroutine, Type

import tradepy


NoArgsNoReturnAsyncFuncT = Callable[[], Coroutine[Any, Any, None]]
NoArgsNoReturnDecorator = Callable[[NoArgsNoReturnAsyncFuncT], NoArgsNoReturnAsyncFuncT]


def repeat_every(
    *,
    seconds: float,
    wait_first: bool = False,
    logger: logging.Logger | None = None,
    raise_exceptions: bool = True,
    ignore_exceptions: list[Type[Exception]] | None = None,
    max_repetitions: int | None = None,
) -> NoArgsNoReturnDecorator:
    """
    NOTE: copied and modified from `https://github.com/dmontagu/fastapi-utils/blob/master/fastapi_utils/tasks.py`

    This function returns a decorator that modifies a function so it is periodically re-executed after its first call.

    The async function it decorates should accept no arguments and return nothing. If necessary, this can be accomplished
    by using `functools.partial` or otherwise wrapping the target function prior to decoration.

    Parameters
    ----------
    seconds: float
        The number of seconds to wait between repeated calls
    wait_first: bool (default False)
        If True, the function will wait for a single period before the first call
    logger: Optional[logging.Logger] (default None)
        The logger to use to log any exceptions raised by calls to the decorated function.
        If not provided, exceptions will not be logged by this function (though they may be handled by the event loop).
    raise_exceptions: bool (default False)
        If True, errors raised by the decorated function will be raised to the event loop's exception handler.
        Note that if an error is raised, the repeated execution will stop.
        Otherwise, exceptions are just logged and the execution continues to repeat.
        See https://docs.python.org/3/library/asyncio-eventloop.html#asyncio.loop.set_exception_handler for more info.
    ignore_exceptions: Optional[List[Type[Exception]]] (default None)
        The exceptions in this provided list will be ignored regardless `raise_exceptions` is `True` or `False
    max_repetitions: Optional[int] (default None)
        The maximum number of times to call the repeated function. If `None`, the function is repeated forever.
    """

    def decorator(func: NoArgsNoReturnAsyncFuncT) -> NoArgsNoReturnAsyncFuncT:
        """
        Converts the decorated function into a repeated, periodically-called version of itself.
        """
        assert asyncio.iscoroutinefunction(func), "The repeated function must be async"

        @wraps(func)
        async def wrapped() -> None:
            repetitions = 0

            async def loop() -> None:
                nonlocal repetitions
                if wait_first:
                    await asyncio.sleep(seconds)
                while max_repetitions is None or repetitions < max_repetitions:
                    try:
                        await func()  # type: ignore
                        repetitions += 1
                    except Exception as exc:
                        trace_msg = "".join(
                            format_exception(type(exc), exc, exc.__traceback__)
                        )

                        if ignore_exceptions and isinstance(
                            exc, tuple(ignore_exceptions)
                        ):
                            if logger:
                                logger.warning(f"抛出异常{type(exc)}, 但是主动忽略: {trace_msg}")
                        else:
                            if logger:
                                logger.error(trace_msg)
                            if raise_exceptions:
                                raise exc
                    await asyncio.sleep(seconds)

            ensure_future(loop())

        return wrapped

    return decorator


def with_redis_lock(key: str, **lock_args):
    def decor(func):
        @wraps(func)
        async def inner(*args, **kwargs):
            with tradepy.config.common.get_redis_client().lock(key, **lock_args):
                if asyncio.iscoroutinefunction(func):
                    return await func(*args, **kwargs)
                return func(*args, **kwargs)

        return inner

    return decor


def use_cache(getter, setter):
    def decor(func):
        @wraps(func)
        async def inner(*args, **kwargs):
            if (cached := getter()) is not None:
                return cached

            result = await func(*args, **kwargs)
            setter(result)
            return result

        return inner

    return decor
